import moment from 'moment';

/**
 * WebSocket服务类
 * 用于管理WebSocket连接、消息处理和重连机制
 */
export class WebSocketService {
  /**
   * 构造函数
   * @param {string} url - WebSocket服务器地址
   */
  constructor(url) {
    this.url = url;                       // WebSocket服务器URL
    this.socket = null;                   // WebSocket实例
    this.isConnected = false;             // 连接状态标志
    this.reconnectAttempts = 0;           // 当前重连尝试次数
    this.maxReconnectAttempts = 5;        // 最大重连尝试次数
    this.reconnectInterval = 3000;        // 重连间隔时间(毫秒)
    this.messageHandlers = [];            // 消息处理函数数组
  }

  /**
   * 建立WebSocket连接
   * 如果已经连接或正在连接中，则不会重复连接
   */
  connect() {
    // 检查是否已经连接或正在连接中
    if (this.socket && (this.socket.readyState === WebSocket.OPEN || this.socket.readyState === WebSocket.CONNECTING)) {
      // console.log('WebSocket已连接或正在连接中');
      return;
    }

    try {
      // 创建新的WebSocket实例
      this.socket = new WebSocket(this.url);

      // 连接成功事件处理
      this.socket.onopen = () => {
        console.log('WebSocket连接已建立');
        this.isConnected = true;
        this.reconnectAttempts = 0;  // 重置重连计数器
      };

      // 接收消息事件处理
      this.socket.onmessage = (event) => {
        try {
          // 解析接收到的JSON数据
          const data = JSON.parse(event.data);
          
          // 检查是否是新消息事件
          if (data.EventName === "MSGNEW" && data.Payload) {
            // 构建标准消息对象，确保结构与store期望的完全一致
            const messageData = {
              Payload: {
                Text: data.Payload.Payload.Text || '',
                TrText: data.Payload.Payload.TrText || '',
                Media: data.Payload.Payload.Media || [],
                Contacts: data.Payload.Payload.Contacts || [],
                Contactsname: data.Payload.Payload.Contactsname || '',
                LinkBody: data.Payload.Payload.LinkBody || null,
                Duration: data.Payload.Duration || 0,
                Title: data.Payload.Title || '',
                Description: data.Payload.Description || '',
                Url: data.Payload.Url || '',
                Name: data.Payload.Name || '',
                Phone: data.Payload.Phone || '',
                uid: data.Payload.uid,           // 添加uid字段
                contactId: data.Payload.ContactId // 添加contactId字段
              },
              From: data.Payload.From,
              To: data.Payload.To,
              MsgType: data.Payload.MsgType,
              Dr: data.Payload.Dr,
              Ts: data.Payload.Ts,
              MsgId: data.Payload.MsgId,
              Packedid: data.Payload.Packedid,
              uid: data.Payload.uid,           // 添加uid字段到顶层
              contactId: data.Payload.ContactId // 添加contactId字段到顶层
            };
            
            // 调用所有注册的消息处理函数，传递完整的消息数据
            this.messageHandlers.forEach(handler => handler({
              type: 'MSGNEW',
              data: messageData
            }));
          } else {
            // 对于非新消息事件，直接传递原始数据
            this.messageHandlers.forEach(handler => handler({
              type: data.EventName,
              data: data
            }));
          }
        } catch (error) {
          console.error('处理WebSocket消息时出错:', error);
        }
      };

      // 连接关闭事件处理
      this.socket.onclose = (event) => {
        this.isConnected = false;
        console.log(`WebSocket连接已关闭: ${event.code} ${event.reason}`);
        // 尝试重新连接
        this.attemptReconnect();
      };

      // 连接错误事件处理
      this.socket.onerror = (error) => {
        // console.error('WebSocket连接错误:', error);
      };
    } catch (error) {
      // console.error('创建WebSocket连接时出错:', error);
    }
  }

  /**
   * 尝试重新连接
   * 在连接断开后自动调用，最多尝试maxReconnectAttempts次
   */
  attemptReconnect() {
    if (this.reconnectAttempts < this.maxReconnectAttempts) {
      this.reconnectAttempts++;
      // console.log(`尝试重新连接 (${this.reconnectAttempts}/${this.maxReconnectAttempts})...`);
      // 延迟一段时间后尝试重连
      setTimeout(() => this.connect(), this.reconnectInterval);
    } else {
      console.error('达到最大重连次数，停止重连');
    }
  }

  /**
   * 断开WebSocket连接
   * 主动关闭连接并清理资源
   */
  disconnect() {
    if (this.socket) {
      this.socket.close();
      this.socket = null;
      this.isConnected = false;
    }
  }

  /**
   * 发送消息到服务器
   * @param {object|string} message - 要发送的消息，可以是对象或字符串
   * @returns {boolean} - 发送是否成功
   */
  send(message) {
    if (this.socket && this.socket.readyState === WebSocket.OPEN) {
      // 如果消息是对象，则转换为JSON字符串
      const messageString = typeof message === 'string' ? message : JSON.stringify(message);
      this.socket.send(messageString);
      return true;
    } else {
      // console.error('WebSocket未连接，无法发送消息');
      return false;
    }
  }

  /**
   * 添加消息处理函数
   * @param {Function} handler - 消息处理函数，接收解析后的消息数据作为参数
   */
  addMessageHandler(handler) {
    if (typeof handler === 'function' && !this.messageHandlers.includes(handler)) {
      this.messageHandlers.push(handler);
    }
  }

  /**
   * 移除消息处理函数
   * @param {Function} handler - 要移除的消息处理函数
   */
  removeMessageHandler(handler) {
    const index = this.messageHandlers.indexOf(handler);
    if (index !== -1) {
      this.messageHandlers.splice(index, 1);
    }
  }
}